import CredentialsProvider from "next-auth/providers/credentials"
import { getOrCreateSAMLUser, validateSAMLUserData } from '@/lib/users/saml-service'
import { encode } from 'next-auth/jwt'
import type { User } from 'next-auth'
import type { SAMLUser } from './utils'
import { debugLog, debugError, debugSuccess, debugProcess } from '@/lib/debug-utils'

interface SAMLProviderOptions {
  id: string
  name: string
  idp: {
    sso_login_url: string
    sso_logout_url: string
    certificates: string[]
  }
  sp: {
    entity_id: string
    private_key: string
    certificate: string
    assert_endpoint: string
  }
}

export function SAMLProvider(options: SAMLProviderOptions) {
  return CredentialsProvider({
    id: options.id,
    name: options.name,
    credentials: {
      user: { 
        label: "User Data", 
        type: "text" 
      }
    },
    async authorize(credentials) {
      debugLog('🔍 SAMLProvider.authorize called with credentials:', credentials);
      
      try {
        debugLog('🔍 Checking credentials.user:', {
          hasCredentials: !!credentials,
          hasUser: !!credentials?.user,
          userType: typeof credentials?.user,
          userValue: credentials?.user?.substring?.(0, 100) + '...'
        });
        
        if (!credentials?.user) {
          debugError('No user data provided in credentials')
          return null
        }

        debugProcess('SAML Provider: Processing user data')
        
        // 사용자 데이터 파싱 (UTF-8 처리 개선)
        const userDataString = credentials.user
        debugLog('🔤 Raw user data string:', userDataString.substring(0, 200) + '...')
        
        let userData;
        try {
          userData = JSON.parse(userDataString);
          debugSuccess('JSON parsing successful:', userData);
        } catch (parseError) {
          debugError('JSON parsing failed:', parseError);
          debugError('Raw string that failed to parse:', userDataString);
          return null;
        }
        
        // 파싱된 데이터의 UTF-8 확인
        debugLog('🔤 Parsed user data UTF-8 check:', {
          name: userData.name,
          nameLength: userData.name?.length,
          charCodes: userData.name ? [...userData.name].map(c => c.charCodeAt(0)) : []
        })
        
        if (!userData.id || !userData.email) {
          debugError('Invalid SAML user data:', userData)
          return null
        }

        debugSuccess('SAML Provider: User authenticated successfully', {
          id: userData.id,
          email: userData.email,
          name: userData.name
        })

        // 🔥 SAML 사용자 데이터 검증
        debugProcess('Validating SAML user data structure...');
        const isValidData = await validateSAMLUserData(userData)
        debugLog('Validation result:', isValidData);
        if (!isValidData) {
          debugError('Invalid SAML user data structure:', userData)
          return null
        }

        // 🔥 JIT (Just-In-Time) 사용자 생성 또는 조회
        debugProcess('Creating/getting SAML user from database...');
        const userCreateData = {
          email: userData.email,
          name: userData.name,
          companyId: undefined,
          techCompanyId: undefined,
          domain: userData.domain
        };
        debugLog('User create data:', userCreateData);
        
        const dbUser = await getOrCreateSAMLUser(userCreateData)
        debugLog('Database user result:', dbUser);
        
        if (!dbUser) {
          debugError('Failed to get or create SAML user')
          return null
        }
        
        // DB에서 가져온 실제 사용자 정보 반환
        const userResult = {
          id: String(dbUser.id),                 // DB의 실제 ID
          name: dbUser.name,                     // DB의 실제 이름
          email: dbUser.email,                   // DB의 실제 이메일
          companyId: dbUser.companyId,           // DB의 실제 회사 ID
          techCompanyId: dbUser.techCompanyId,   // DB의 실제 기술회사 ID
          domain: dbUser.domain,                 // DB의 실제 도메인
          imageUrl: dbUser.imageUrl,             // DB의 실제 이미지 URL
        }
        
        debugSuccess('SAML Provider: Returning user data to NextAuth:', userResult)
        return userResult
      } catch (error) {
        debugError('SAML Provider: Authentication failed', {
          error: error instanceof Error ? error.message : String(error),
          stack: error instanceof Error ? error.stack : undefined,
          errorType: typeof error,
          credentials: credentials
        });
        return null
      }
    }
  })
}

// SAML 로그인 URL 생성 헬퍼 함수
export function getSAMLLoginUrl(options: SAMLProviderOptions): string {
  const params = new URLSearchParams({
    SAMLRequest: 'placeholder', // 실제로는 createAuthnRequest()로 생성
    RelayState: options.sp.assert_endpoint,
  })
  
  return `${options.idp.sso_login_url}?${params.toString()}`
}

// SAML 설정 검증
export function validateSAMLOptions(options: SAMLProviderOptions): boolean {
  const required = [
    options.idp.sso_login_url,
    options.sp.entity_id,
    options.sp.assert_endpoint
  ]
  
  return required.every(field => field && field.length > 0)
}

// SAMLProvider의 authorize 함수를 직접 호출하기 위한 헬퍼
export async function authenticateSAMLUser(userData: SAMLUser) {
  debugLog('authenticateSAMLUser called with:', userData);
  
  try {
    // SAMLProvider 대신 직접 로직 실행 (Provider 래퍼 없이)
    debugProcess('SAML User Authentication: Processing user data')
    
    // 사용자 데이터 검증
    if (!userData.id || !userData.email) {
      debugError('Invalid SAML user data:', userData)
      return null
    }

    debugSuccess('SAML User data validated successfully', {
      id: userData.id,
      email: userData.email,
      name: userData.name
    })

    // 🔥 SAML 사용자 데이터 검증
    debugLog('Validating SAML user data structure...');
    const isValidData = await validateSAMLUserData(userData)
    debugLog('Validation result:', isValidData);
    if (!isValidData) {
      debugError('Invalid SAML user data structure:', userData)
      return null
    }

    // 🔥 JIT (Just-In-Time) 사용자 생성 또는 조회
    debugLog('Creating/getting SAML user from database...');
    const userCreateData = {
      email: userData.email,
      name: userData.name,
      companyId: undefined,
      techCompanyId: undefined,
      domain: userData.domain
    };
    debugLog('User create data:', userCreateData);
    
    const dbUser = await getOrCreateSAMLUser(userCreateData)
    debugLog('Database user result:', dbUser);
    
    if (!dbUser) {
      debugError('Failed to get or create SAML user')
      return null
    }
    
    // DB에서 가져온 실제 사용자 정보 반환
    const userResult = {
      id: String(dbUser.id),                 // DB의 실제 ID
      name: dbUser.name,                     // DB의 실제 이름
      email: dbUser.email,                   // DB의 실제 이메일
      companyId: dbUser.companyId,           // DB의 실제 회사 ID
      techCompanyId: dbUser.techCompanyId,   // DB의 실제 기술회사 ID
      domain: dbUser.domain,                 // DB의 실제 도메인
      imageUrl: dbUser.imageUrl,             // DB의 실제 이미지 URL
    }
    
    debugSuccess('SAML User Authentication completed:', userResult)
    return userResult;
    
  } catch (error) {
    debugError('authenticateSAMLUser error:', {
      error: error instanceof Error ? error.message : String(error),
      stack: error instanceof Error ? error.stack : undefined,
      userData
    });
    return null;
  }
}

// NextAuth JWT 토큰 생성 헬퍼
export async function createNextAuthToken(user: User): Promise<string> {
  const token = {
    id: user.id,
    email: user.email,
    name: user.name,
    companyId: user.companyId,
    techCompanyId: user.techCompanyId,
    domain: user.domain,
    imageUrl: user.imageUrl,
    iat: Math.floor(Date.now() / 1000),
    exp: Math.floor(Date.now() / 1000) + (30 * 24 * 60 * 60) // 30일
  };

  const secret = process.env.NEXTAUTH_SECRET!;
  return await encode({ token, secret });
}

// NextAuth 세션 쿠키 이름 가져오기
export function getSessionCookieName(): string {
  return process.env.NODE_ENV === 'production' 
    ? '__Secure-next-auth.session-token' 
    : 'next-auth.session-token';
}